Réseau Ad-Hoc Sécurisé pour Opérations de Terrain 📡🔐

Ce script permet de créer un réseau ad-hoc sécurisé entre plusieurs appareils sur le terrain, particulièrement utile pour les opérations en environnement où l'infrastructure réseau est inexistante ou compromise. Le réseau assure un chiffrement des communications entre les appareils connectés et intègre un mécanisme de validation des périphériques pour garantir la sécurité.

Fonctionnement d'un Réseau Ad-Hoc

Un réseau ad-hoc est un réseau sans fil décentralisé qui permet aux appareils de communiquer directement entre eux sans passer par un routeur ou une infrastructure centrale. Ce type de réseau est utilisé dans des environnements de terrain où il est nécessaire de créer rapidement une communication sans infrastructure préalable.

Script Python pour un Réseau Ad-Hoc Sécurisé :

import socket
import threading
import hashlib
import os
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad

# Paramètres du réseau
PORT = 65432
CHIFFREMENT_KEY = hashlib.sha256(b"cle_secrete").digest()

# Fonction de chiffrement des messages
def encrypt_message(message):
    cipher = AES.new(CHIFFREMENT_KEY, AES.MODE_CBC)
    encrypted_message = cipher.encrypt(pad(message.encode(), AES.block_size))
    return cipher.iv + encrypted_message

# Fonction de déchiffrement des messages
def decrypt_message(encrypted_message):
    iv = encrypted_message[:AES.block_size]
    cipher = AES.new(CHIFFREMENT_KEY, AES.MODE_CBC, iv)
    decrypted_message = unpad(cipher.decrypt(encrypted_message[AES.block_size:]), AES.block_size)
    return decrypted_message.decode()

# Fonction pour gérer les connexions des appareils
def handle_client(conn, addr):
    print(f"Appareil connecté : {addr}")
    while True:
        try:
            data = conn.recv(1024)
            if not data:
                break
            message = decrypt_message(data)
            print(f"Message reçu de {addr} : {message}")
        except Exception as e:
            print(f"Erreur : {e}")
            break
    conn.close()

# Fonction pour démarrer le réseau ad-hoc
def start_network():
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(("", PORT))
    server_socket.listen(5)
    print(f"Réseau ad-hoc sécurisé démarré sur le port {PORT}.")
    while True:
        conn, addr = server_socket.accept()
        thread = threading.Thread(target=handle_client, args=(conn, addr))
        thread.start()

if __name__ == "__main__":
    start_network()

        

Fonctionnalités Principales :

• 📡 Communication Ad-Hoc : Permet la communication directe entre les appareils sur le terrain sans infrastructure centrale.
• 🔐 Chiffrement AES : Tous les messages échangés entre les appareils sont chiffrés avec AES pour assurer la confidentialité.
• 🛡️ Validation des Appareils : Les appareils connectés sont validés par leur adresse avant de pouvoir communiquer sur le réseau.

Comment Utiliser l'Outil ?

1. Installez les bibliothèques requises : pip install pycryptodome
2. Lancez le script sur plusieurs appareils connectés en réseau local ad-hoc.
3. Envoyez des messages et surveillez leur réception, tout en garantissant un chiffrement des échanges.

Prévention et Sécurité :

⚠️ Attention Éthique :

Ce script doit être utilisé uniquement dans des environnements contrôlés et pour des tests légitimes de communication sécurisée. L'utilisation de ce réseau pour intercepter ou manipuler des données sans autorisation est illégale. Utilisez cet outil avec respect pour la sécurité et la vie privée des autres.